Currently, Cellular Neural Networks (CNN) build a paradigm based on a set of canonical differential equations (Equations 1-3 below) that define a set of nonlinear dynamic interactions between cells in a (usually two dimensional) grid. There are several degrees of freedom in setting up these interactions in the form of feedback and feedforward weights (namely the values A and B in Equation 1) and the initial conditions of the states (x(t=0) in Equation 1) and the bias currents (I in Equation 3). CNN is in fact programmed by way of manipulating these values. The nonlinearity comes from the nonlinear nature of the function (‘f’ in Equation 2). The function “f” can take on different shapes and characteristics. Programming a particular function is then delegated to finding the right combination of A, B, x(t=0), and I that yields the desired outcome or outputs (y) given a pattern of inputs (u). This type of programmability is quite flexible.
CNN is a hybrid of Cellular Automata and Neural Networks (hence the name Cellular Neural Networks) and it incorporates the best features of both concepts. Like Neural Networks, its continuous time feature allows real-time signal processing, and like Cellular Automata its local interconnection feature makes physical realization in VLSI possible. Its grid-like structure is suitable for the solution of a high-order system of first order nonlinear differential equations on-line and in real-time. In summary, CNN can be viewed as an analog nonlinear dynamic processor array. The basic unit of CNN is called a cell. Each cell receives input from its immediate neighbors (and itself via feedback), and also from external sources (e.g., the sensor array points and/or previous layers).
The canonical CNN equation summarizes these relationships:
                                                                                          τ                  ij                                ⁢                                                                            x                      .                                        ij                                    ⁡                                      (                    t                    )                                                              =                            ⁢                                                -                                                            x                      ij                                        ⁡                                          (                      t                      )                                                                      +                                                      ∑                                          kl                      ∈                                                                        N                          r                                                ⁡                                                  (                          ij                          )                                                                                                      ⁢                                                            A                                              ij                        ;                        kl                                                              ⁡                                          (                                                                                                    y                            kl                                                    ⁡                                                      (                            t                            )                                                                          ,                                                                              y                            ij                                                    ⁡                                                      (                            t                            )                                                                                              )                                                                      +                                                                                                      ⁢                                                                    ∑                                          kl                      ∈                                                                        N                          r                                                ⁡                                                  (                          ij                          )                                                                                                      ⁢                                                            B                                              ij                        ;                        kl                                                              ⁡                                          (                                                                                                    u                            kl                                                    ⁡                                                      (                            t                            )                                                                          ,                                                                              u                            ij                                                    ⁡                                                      (                            t                            )                                                                                              )                                                                      +                                  I                  ij                                                                                        Equation        ⁢                                  ⁢        1            yij=ƒ(xij)  Equation 2andIij=I  Equation 3where u represents the input, x represents the state, and y represents a nonlinear function of the state associated with a cell (or neuron), and A and B represent the cloning templates.
In a typical CNN, local connections between the neighbors (feedback weights, or the entries of the matrix A in Equation 1), along with connections form the sensory array (input weights, or entries of the matrix B in Equation 1) form the programmable cloning templates. Cloning templates to perform numerous types of visual processing tasks have been developed. Each template is specific to a particular application, e.g., a cloning template for edge detection or binocular stereo. Cellular neural networks are attractive in image processing because of their programmability: One needs to change only the template to perform a different iconic task.
Despite such flexibility, critical problems arise when one tries to implement CNN in electronic circuits. The CNN model described in Equations (1-3), however, is not suitable for direct VLSI implementation. In an integrated circuit implementation of the CNN model, the summation equation is a current based computation, as the circuit model in FIG. 1 suggests. By Kirchoff's law, all currents coming into the node that defines the state of the cell (x) must add to zero. As the intrinsic resistance values (R) are very large and capacitance values are very small, little charge is required to maintain a particular voltage. This also means that the current required to alter the voltage value of the state is relatively very small. The values of the noise currents are of sufficient magnitude to make significant difference. When one adds to that the fact that the transistor characteristics can generally vary as much as 20% within the same chip substrate, it becomes clear that the (x) node is highly likely to charge up or down to a power rail. One remedy is adding significant capacitance to each node. This is not desirable at all since it requires precious VLSI real estate and furthermore increases the response time of the cell. The VLSI implementations of the current CNN models have not addressed this issue, and as such, the current CNN model described in Equations (1-3) is not suitable for direct VLSI implementation.